const path = require('path');

// 在Electron打包应用中，依赖可能无法被正确找到。
// 这个函数尝试用标准 `require` 加载模块，如果失败，
// 它会尝试一个基于打包后应用结构的备用路径。
function customRequire(moduleName) {
    try {
        // 1. 尝试标准 require，适用于开发环境和某些打包场景
        return require(moduleName);
    } catch (e1) {
        // 2. 如果标准 require 失败，则为打包后的 Electron 应用构建备用路径
        // process.resourcesPath 指向应用根目录下的 resources 文件夹
        const packagedPath = path.join(process.resourcesPath, 'app', 'node_modules', moduleName);
        console.log(`标准 require 失败，尝试从打包路径加载: ${packagedPath}`);
        try {
            return require(packagedPath);
        } catch (e2) {
            // 如果两种方法都失败，则抛出原始错误，因为它更有可能描述根本问题
            console.error(`从打包路径加载失败: ${e2.message}`);
            throw e1;
        }
    }
}

// 添加日志工具函数，用于将日志输出到控制台而不是文件
function log(message, level = 'info') {
    const timestamp = new Date().toISOString();
    // 根据日志级别设置不同的前缀
    let prefix = '';
    switch(level.toLowerCase()) {
        case 'error':
            prefix = '❌ ';
            break;
        case 'warning':
            prefix = '⚠️ ';
            break;
        case 'success':
            prefix = '✅ ';
            break;
        case 'info':
        default:
            prefix = 'ℹ️ ';
            break;
    }
    
    const formattedMessage = `[${timestamp}] [${level.toUpperCase()}] ${prefix}${message}`;
    console.log(formattedMessage);
    return formattedMessage;
}

function error(message, errorObj) {
    const timestamp = new Date().toISOString();
    const formattedMessage = `[${timestamp}] [ERROR] ❌ ${message}`;
    console.error(formattedMessage);
    
    // 添加更详细的错误信息
    if (errorObj) {
        if (errorObj.stack) {
            console.error(`[${timestamp}] [ERROR] 错误堆栈:`, errorObj.stack);
        }
        
        // 添加错误类型信息
        if (errorObj.name) {
            console.error(`[${timestamp}] [ERROR] 错误类型: ${errorObj.name}`);
        }
        
        // 如果是网络错误，添加更多诊断信息
        if (errorObj.message && (
            errorObj.message.includes('net::') || 
            errorObj.message.includes('timeout') || 
            errorObj.message.includes('Navigation')
        )) {
            console.error(`[${timestamp}] [ERROR] 可能是网络问题或页面加载超时`);
        }
    }
    
    return formattedMessage;
}

// 数据清理工具函数
function cleanupOldDataFiles(dataDir, filePattern = '*.json') {
    const fs = require('fs');
    const glob = require('glob');
    
    try {
        // 规范化路径
        const normalizedDataDir = path.normalize(dataDir);
        log(`正在检查数据目录: ${normalizedDataDir}`, 'info');
        
        if (!fs.existsSync(normalizedDataDir)) {
            log(`数据目录不存在: ${normalizedDataDir}`, 'info');
            return;
        }
        
        // 查找匹配的文件
        const pattern = path.normalize(path.join(normalizedDataDir, filePattern));
        log(`搜索模式: ${pattern}`, 'info');
        const files = glob.sync(pattern);
        
        if (files.length === 0) {
            log(`没有找到需要清理的文件: ${pattern}`, 'info');
            return;
        }
        
        log(`找到 ${files.length} 个旧数据文件，开始清理...`, 'info');
        
        // 删除找到的文件
        let deletedCount = 0;
        files.forEach(file => {
            try {
                fs.unlinkSync(file);
                log(`已删除旧数据文件: ${path.basename(file)}`, 'success');
                deletedCount++;
            } catch (deleteError) {
                error(`删除文件失败 ${file}: ${deleteError.message}`, deleteError);
            }
        });
        
        log(`数据清理完成，共删除 ${deletedCount} 个文件`, 'success');
        
    } catch (cleanupError) {
        error(`数据清理过程中发生错误: ${cleanupError.message}`, cleanupError);
        throw cleanupError;
    }
}

// 针对特定模块的数据清理函数
function cleanupModuleData(moduleName) {
    const pathUtils = require('./utils/path-utils');
    
    try {
        const dataDir = pathUtils.getDataPath(moduleName);
        log(`开始清理 ${moduleName} 模块的旧数据...`, 'info');
        cleanupOldDataFiles(dataDir);
    } catch (error) {
        error(`清理 ${moduleName} 模块数据失败: ${error.message}`, error);
        throw error;
    }
}

module.exports = { customRequire, log, error, cleanupOldDataFiles, cleanupModuleData };